function FindBestResponse(const question: ucs4): string;
var
  i, j: Integer;
  questionStr, pattern, context: string;
  scores: array of Double;
  maxScore: Double;
  bestIndex: Integer;
  foundDirectMatch: Boolean;
begin
  questionStr := UTF8LowerCase(question.ToUTF8);
  questionStr := questionStr.Trim;
  WriteLn('Debug: Анализируем вопрос: "', questionStr, '"');

  // Получаем контекст диалога
  context := GetConversationContext;

  WriteLn('Debug: Контекст: ', context);

  // Проверяем продолжение диалога
  if context.Contains('как дела') and questionStr.Contains('норм') then
  begin
    Result := 'Рад слышать! Чем еще могу помочь?';
    Exit;
  end;

  if context.Contains('погод') and questionStr.Contains('солн') then
  begin
    Result := 'Солнечная погода - это прекрасно! Хотите обсудить планы на день?';
    Exit;
  end;

  // Сначала проверяем прямые совпадения
  foundDirectMatch := False;
  for i := 0 to High(ResponseTemplates) do
  begin
    for j := 0 to High(ResponseTemplates[i].Patterns) do
    begin
      pattern := UTF8LowerCase(ResponseTemplates[i].Patterns[j]);

      // Прямое вхождение или очень похожая фраза
      if (questionStr = pattern) or 
         (Pos(pattern, questionStr) > 0) or
         (questionStr.Contains(pattern)) then
      begin
        WriteLn('Debug: Прямое совпадение с шаблоном: ', pattern);
        Result := ResponseTemplates[i].Response;
        Exit;
      end;
    end;
  end;

  // Если нет прямых совпадений, используем Word2Vec (с проверкой!)
  if (WordEmbeddings <> nil) and (questionStr <> '') and 
     (Assigned(WordEmbeddings.FVocab)) and (WordEmbeddings.FVocab.Count > 0) then 
  begin
    try
      SetLength(scores, Length(ResponseTemplates));
      maxScore := 0;
      bestIndex := -1;

      for i := 0 to High(ResponseTemplates) do begin
        scores[i] := 0;
        for j := 0 to High(ResponseTemplates[i].Patterns) do begin
          try
            pattern := UTF8LowerCase(ResponseTemplates[i].Patterns[j]);
            scores[i] := Max(scores[i], WordEmbeddings.FastSimilarity(questionStr, pattern));
          except
            on E: Exception do
            begin
              WriteLn('Ошибка в FastSimilarity: ', E.Message);
              scores[i] := 0;
            end;
          end;
        end;

        if scores[i] > maxScore then begin
          maxScore := scores[i];
          bestIndex := i;
        end;
      end;

      if (bestIndex >= 0) and (maxScore > 0.4) then // Понижаем порог
      begin
        WriteLn('Debug: Найден шаблонный ответ [', 
          ResponseTemplates[bestIndex].Patterns[0], 
          '] score=', maxScore:0:2);
        Result := ResponseTemplates[bestIndex].Response;
        Exit;
      end;
    except
      on E: Exception do
      begin
        WriteLn('Ошибка в Word2Vec поиске: ', E.Message);
        // Продолжаем без Word2Vec
      end;
    end;
  end
  else
  begin
    WriteLn('Debug: WordEmbeddings не доступен, используем только шаблоны');
  end;

  // Если ничего не найдено
  WriteLn('Debug: Шаблон не найден');
  Result := '';
end;

procedure ProcessUserInput;
var
  inputText: ucs4;
  response, userMessage: string;
  filesList: TStringList;
  inputMatrix, outputMatrix: TDoubleMatrix;
begin
  filesList := TStringList.Create;
  try
    // 1. Получаем пользовательский ввод
    UserInput := GetUserInput(POST_FILE, filesList);
    inputText := UserInput.Message;
    userMessage := inputText.ToUTF8;

    if inputText.Length = 0 then begin
      WriteLn('Пустое сообщение, пропускаем');
      Exit;
    end;

    WriteLn('Обработка сообщения: "', userMessage, '"');
    LastUserMessage := userMessage;

    // ✅ УПРОЩЕННАЯ ПРОВЕРКА МОДЕЛИ
    WriteLn('Проверка модели: InputSize=', TransformerModel.Config.InputSize);

    // 2. Добавляем сообщение в историю
    UpdateConversationContext(userMessage, '');

    // 3. Создаем входные данные
    WriteLn('Создание входных данных...');
    inputMatrix := CreateContextEnrichedInput(inputText, '');

    WriteLn('inputMatrix создан: ', Length(inputMatrix), 'x', 
            IfThen(Length(inputMatrix) > 0, IntToStr(Length(inputMatrix[0])), '0'));

    // 4. Прямой проход через модель
    WriteLn('Запуск прямого прохода...');
    SetLength(outputMatrix, 0, 0);
    ForwardTransformer(TransformerModel, inputMatrix, outputMatrix);

    WriteLn('outputMatrix получен: ', Length(outputMatrix), 'x', 
            IfThen(Length(outputMatrix) > 0, IntToStr(Length(outputMatrix[0])), '0'));

    // 5. Генерируем ответ через шаблоны (упрощенно)
    response := FindBestResponse(inputText);

    // 6. Если шаблонный ответ не найден, используем fallback
    if response = '' then begin
      WriteLn('Шаблонный ответ не найден, используем вывод трансформера');
      response := GenerateResponseFromOutput(outputMatrix);
    end;

    // 7. Выводим ответ
    if response <> '' then
    begin
      LastAIResponse := response;
      UpdateConversationContext('', response); // Добавляем ответ в историю

      WriteLn('Ответ AI:');
      WriteLn(response);
    end
    else
    begin
      response := 'Я не совсем понял ваш вопрос. Можете уточнить?';
      WriteLn('Ответ AI (fallback): ', response);
    end;

  except
    on E: Exception do
    begin
      WriteLn('Ошибка в ProcessUserInput: ', E.Message);
      WriteLn('Тип ошибки: ', E.ClassName);
      WriteLn('Call stack:');
      DumpExceptionBackTrace(Output);
      response := 'Извините, произошла техническая ошибка. Попробуйте еще раз.';
      WriteLn('Ответ AI: ', response);
    end;
  end;
  filesList.Free;
end;

procedure Initialize;
var 
  defaultConfig: TTransformerConfig;
  TrainingData: TTrainingDataset;
  i: Integer;
begin
  try
    if FileExists(WORD2VEC_MODEL) then
    begin
      WriteLn('Loading Word2Vec model...');
      WordEmbeddings := TWordEmbeddings.Create(WORD2VEC_MODEL, 5000);
      
      // ✅ ПРОВЕРКА УСПЕШНОСТИ ЗАГРУЗКИ
      if (WordEmbeddings.FVocab = nil) or (WordEmbeddings.FVocab.Count = 0) then
      begin
        WriteLn('ОШИБКА: Word2Vec модель загружена, но словарь пуст!');
        WordEmbeddings.Free;
        WordEmbeddings := nil;
      end
      else
      begin
        Word2Vec.WordEmbeddings := WordEmbeddings;
        WriteLn('Word2Vec model successfully loaded');
        WriteLn('Vocabulary size: ', WordEmbeddings.FVocab.Count);
        WriteLn('Embedding size: ', WordEmbeddings.EmbeddingSize);

        // Предзагрузка частых слов
        PreloadFrequentWords(WordEmbeddings);
      end;
    end
    else
    begin
      WriteLn('Warning: Word2Vec model file not found: ', WORD2VEC_MODEL);
      WordEmbeddings := nil;
      Word2Vec.WordEmbeddings := nil;
    end;
  except
    on E: Exception do
    begin
      WriteLn('Error loading Word2Vec: ', E.Message);
      WordEmbeddings := nil;
      Word2Vec.WordEmbeddings := nil;
    end;
  end;

  // ✅ ПРОДОЛЖАЕМ ДАЖЕ ЕСЛИ Word2Vec НЕ ЗАГРУЗИЛСЯ
  WriteLn('WordEmbeddings status: ', IfThen(Assigned(WordEmbeddings), 'LOADED', 'NOT AVAILABLE'));

  LoadResponseTemplates;

  // Создаем временную директорию для вложений
  if not DirectoryExists(TEMP_DIR) then
    ForceDirectories(TEMP_DIR);

  // Инициализация истории диалога
  ConversationHistory := TStringList.Create;
  ConversationHistory.Delimiter := '|';
  ConversationHistory.StrictDelimiter := True;
  LastUserMessage := '';

  // Загружаем и фильтруем данные
  LoadTrainingData(TrainingData, 'training_data.txt');
  WriteLn('Loaded ', Length(TrainingData), ' examples before filtering');
  FilterEmptyExamples(TrainingData);
  WriteLn('After filtering: ', Length(TrainingData), ' examples');

  // ✅ СОЗДАЕМ КОНФИГУРАЦИЮ
  with defaultConfig do
  begin
    InputSize := 300;
    NumLayers := 2;
    NumHeads := 4;
    FFNDim := 512;
    MaxSeqLength := 1000;
    DropoutRate := 0.1;
    WeightDecay := 0.0001;
    GradientClipValue := 1.0;
    UseLayerNorm := True;
  end;

  WriteLn('Инициализация модели трансформера...');
  InitTransformer(TransformerModel, defaultConfig);

  // ✅ ПРОВЕРЯЕМ ИНИЦИАЛИЗАЦИЮ
  WriteLn('Модель инициализирована: InputSize=', TransformerModel.Config.InputSize);
  
  if not ValidateModelStructure(TransformerModel) then
  begin
    WriteLn('КРИТИЧЕСКАЯ ОШИБКА: Модель не прошла валидацию!');
    // Но продолжаем работу - возможно, это ложная тревога
  end;
end;

// Временно закомментируем вызовы, которые могут вызывать проблемы
function TContextManager.GetOptimizedContext(const CurrentMessage: string): string;
var
  i, count: Integer;
  relevantMessages: TStringList;
  maxMessages: Integer;
begin
  // Быстрый выход если история пуста
  if FHistory.Count = 0 then
    Exit('');

  WriteLn('ContextManager: получение контекста из ', FHistory.Count, ' сообщений');
  
  // ✅ ВРЕМЕННО УПРОЩАЕМ - ВОЗВРАЩАЕМ ТОЛЬКО ПОСЛЕДНИЕ СООБЩЕНИЯ
  maxMessages := Min(FMaxContextLength, FHistory.Count);
  Result := '';
  
  for i := FHistory.Count - maxMessages to FHistory.Count - 1 do
  begin
    if i >= 0 then
    begin
      if Result <> '' then Result := Result + #10;
      Result := Result + FHistory[i];
      
      // Ограничиваем длину
      if UTF8Length(Result) > 500 then
      begin
        Result := UTF8Copy(Result, 1, 500) + '...';
        Break;
      end;
    end;
  end;
  
  WriteLn('ContextManager: возвращаем контекст длиной ', UTF8Length(Result));
end;

function GetConversationContext: string;
var
  i: Integer;
begin
  Result := '';
  WriteLn('GetConversationContext: история содержит ', ConversationHistory.Count, ' сообщений');
  
  for i := 0 to ConversationHistory.Count - 1 do
  begin
    WriteLn('  Сообщение ', i, ': ', Copy(ConversationHistory[i], 1, 50));
    Result := Result + ConversationHistory[i] + #10;
  end;
  
  Result := Result.Trim;
  WriteLn('GetConversationContext: итоговый контекст: "', Copy(Result, 1, 100), '"');
end;

procedure ProcessUserInput;
var
  inputText: ucs4;
  response, userMessage: string;
  filesList: TStringList;
  inputMatrix, outputMatrix: TDoubleMatrix;
begin
  filesList := TStringList.Create;
  try
    // 1. Получаем пользовательский ввод
    UserInput := GetUserInput(POST_FILE, filesList);
    inputText := UserInput.Message;
    userMessage := inputText.ToUTF8.Trim;

    if inputText.Length = 0 then begin
      WriteLn('Пустое сообщение, пропускаем');
      Exit;
    end;

    WriteLn('Пользователь: ', userMessage);
    LastUserMessage := userMessage;

    // 2. Добавляем сообщение в историю
    UpdateConversationContext(userMessage, '');

    // 3. Создаем входные данные
    inputMatrix := CreateContextEnrichedInput(inputText, GetConversationContext);

    // 4. Прямой проход через модель (без подробного вывода)
    ForwardTransformer(TransformerModel, inputMatrix, outputMatrix);

    // 5. Генерируем ответ через шаблоны
    response := FindBestResponse(inputText);

    // 6. Если шаблонный ответ не найден, используем вывод трансформера
    if response = '' then begin
      response := GenerateResponseFromOutput(outputMatrix);
    end;

    // 7. Выводим ответ и добавляем в историю
    WriteLn('AI: ', response);
    UpdateConversationContext('', response);

  except
    on E: Exception do
    begin
      WriteLn('Ошибка: ', E.Message);
      response := 'Извините, произошла техническая ошибка. Попробуйте еще раз.';
      WriteLn('AI: ', response);
    end;
  end;
  filesList.Free;
end;

function GenerateResponseFromOutput(const outputMatrix: TDoubleMatrix): string;
var
  i, j: Integer;
  maxVal, minVal, avgVal: Double;
  responseType: Integer;
begin
  if (Length(outputMatrix) = 0) or (Length(outputMatrix[0]) = 0) then begin
    Result := 'Интересно! Расскажите подробнее.';
    Exit;
  end;

  try
    // Анализируем выходные данные
    maxVal := outputMatrix[0][0];
    minVal := outputMatrix[0][0];
    avgVal := 0;
    
    for i := 0 to High(outputMatrix) do begin
      for j := 0 to High(outputMatrix[0]) do begin
        if outputMatrix[i][j] > maxVal then maxVal := outputMatrix[i][j];
        if outputMatrix[i][j] < minVal then minVal := outputMatrix[i][j];
        avgVal := avgVal + outputMatrix[i][j];
      end;
    end;
    
    avgVal := avgVal / (Length(outputMatrix) * Length(outputMatrix[0]));

    // Определяем тип ответа на основе анализа выхода
    if maxVal > 0.5 then
      responseType := 0  // Высокая уверенность
    else if avgVal > 0 then
      responseType := 1  // Средняя уверенность
    else
      responseType := 2; // Низкая уверенность

    // Генерируем ответы на основе типа
    case responseType of
      0: // Высокая уверенность - конкретные ответы
        case Random(4) of
          0: Result := 'Похоже, это важная тема! Хотите обсудить ее подробнее?';
          1: Result := 'Интересный вопрос! Могу рассказать об этом больше.';
          2: Result := 'Понял вас. Что именно вас интересует в этом вопросе?';
          3: Result := 'Это действительно важно. Давайте обсудим детали.';
        end;
      
      1: // Средняя уверенность - нейтральные ответы
        case Random(4) of
          0: Result := 'Интересно! Что вы об этом думаете?';
          1: Result := 'Понятно. Хотите обсудить это подробнее?';
          2: Result := 'Спасибо за информацию! Чем еще могу помочь?';
          3: Result := 'Я вас слушаю. Продолжайте, пожалуйста.';
        end;
      
      2: // Низкая уверенность - уточняющие вопросы
        case Random(4) of
          0: Result := 'Не совсем понял. Можете уточнить ваш вопрос?';
          1: Result := 'Интересно, но мне нужно больше контекста. О чем именно речь?';
          2: Result := 'Хорошо, но я не совсем уверен что вы имеете в виду. Можете объяснить по-другому?';
          3: Result := 'Благодарю за сообщение. Чем еще могу помочь?';
        end;
    end;

  except
    Result := 'Я вас понял. Чем еще могу быть полезен?';
  end;
end;

function FindBestResponse(const question: ucs4): string;
var
  i, j: Integer;
  questionStr, pattern, context: string;
  scores: array of Double;
  maxScore: Double;
  bestIndex: Integer;
begin
  questionStr := UTF8LowerCase(question.ToUTF8);
  questionStr := questionStr.Trim;
  
  // Убираем лишние пробелы и знаки препинания для лучшего сравнения
  questionStr := StringReplace(questionStr, '?', '', [rfReplaceAll]);
  questionStr := StringReplace(questionStr, '!', '', [rfReplaceAll]);
  questionStr := StringReplace(questionStr, '.', '', [rfReplaceAll]);
  questionStr := questionStr.Trim;

  // Получаем контекст диалога
  context := GetConversationContext;

  // Проверяем продолжение диалога
  if context.Contains('как дела') and (questionStr.Contains('хорош') or questionStr.Contains('норм') or questionStr.Contains('отлич')) then
  begin
    Result := 'Рад слышать! Чем еще могу помочь?';
    Exit;
  end;

  if context.Contains('погод') and questionStr.Contains('солн') then
  begin
    Result := 'Солнечная погода - это прекрасно! Хотите обсудить планы на день?';
    Exit;
  end;

  // Сначала проверяем точные совпадения
  for i := 0 to High(ResponseTemplates) do
  begin
    for j := 0 to High(ResponseTemplates[i].Patterns) do
    begin
      pattern := UTF8LowerCase(ResponseTemplates[i].Patterns[j]);
      
      // Точное совпадение или вхождение
      if (questionStr = pattern) or 
         (questionStr.Contains(pattern) and (Length(pattern) > 2)) then
      begin
        Result := ResponseTemplates[i].Response;
        Exit;
      end;
    end;
  end;

  // Если нет точных совпадений, используем Word2Vec (с проверкой!)
  if (WordEmbeddings <> nil) and (questionStr <> '') then 
  begin
    try
      SetLength(scores, Length(ResponseTemplates));
      maxScore := 0;
      bestIndex := -1;

      for i := 0 to High(ResponseTemplates) do begin
        scores[i] := 0;
        for j := 0 to High(ResponseTemplates[i].Patterns) do begin
          try
            pattern := UTF8LowerCase(ResponseTemplates[i].Patterns[j]);
            // Используем самый похожий шаблон из группы
            scores[i] := Max(scores[i], WordEmbeddings.FastSimilarity(questionStr, pattern));
          except
            scores[i] := 0;
          end;
        end;

        if scores[i] > maxScore then begin
          maxScore := scores[i];
          bestIndex := i;
        end;
      end;

      // Более низкий порог для лучшего покрытия
      if (bestIndex >= 0) and (maxScore > 0.3) then
      begin
        Result := ResponseTemplates[bestIndex].Response;
        Exit;
      end;
    except
      // Продолжаем без Word2Vec в случае ошибки
    end;
  end;

  // Если ничего не найдено
  Result := '';
end;

procedure LoadResponseTemplates;
begin
  SetLength(ResponseTemplates, 10); // Увеличиваем до 10 шаблонов

  // Приветствие
  ResponseTemplates[0].Patterns := ['привет', 'здравствуй', 'добрый день', 'хай', 'hello', 'hi', 'доброе утро', 'добрый вечер'];
  ResponseTemplates[0].Response := 'Здравствуйте! Чем могу помочь?';

  // Вопрос о делах
  ResponseTemplates[1].Patterns := ['как дела', 'как жизнь', 'как сам', 'как ты', 'how are you', 'как настроение'];
  ResponseTemplates[1].Response := 'У меня всё отлично! А у вас как дела?';

  // Прощание
  ResponseTemplates[2].Patterns := ['пока', 'до свидания', 'выход', 'закончить', 'bye', 'goodbye', 'до встречи'];
  ResponseTemplates[2].Response := 'До свидания! Буду рад пообщаться снова.';

  // Благодарность
  ResponseTemplates[3].Patterns := ['спасибо', 'благодарю', 'мерси', 'thanks', 'thank you'];
  ResponseTemplates[3].Response := 'Пожалуйста! Обращайтесь ещё.';

  // Вопрос о возможностях
  ResponseTemplates[4].Patterns := ['что ты умеешь', 'твои возможности', 'какие функции', 'что можешь'];
  ResponseTemplates[4].Response := 'Я могу общаться на разные темы, отвечать на вопросы и поддерживать беседу!';

  // Вопрос о имени
  ResponseTemplates[5].Patterns := ['как тебя зовут', 'твое имя', 'who are you', 'кто ты'];
  ResponseTemplates[5].Response := 'Я - чат-бот с искусственным интеллектом!';

  // Вопросы о помощи
  ResponseTemplates[6].Patterns := ['помощь', 'help', 'что делать', 'как быть'];
  ResponseTemplates[6].Response := 'Чем именно я могу вам помочь? Расскажите подробнее о вашей проблеме.';

  // Вопросы о времени
  ResponseTemplates[7].Patterns := ['который час', 'сколько времени', 'what time'];
  ResponseTemplates[7].Response := 'К сожалению, я не могу определить точное время. Рекомендую посмотреть на часы!';

  // Вопросы о погоде
  ResponseTemplates[8].Patterns := ['погода', 'weather', 'какая погода'];
  ResponseTemplates[8].Response := 'Я не имею доступа к актуальным данным о погоде. Лучше посмотреть в специализированном сервисе!';

  // Общие вопросы
  ResponseTemplates[9].Patterns := ['что', 'как', 'где', 'почему', 'when', 'where', 'why'];
  ResponseTemplates[9].Response := 'Интересный вопрос! Можете уточнить, что именно вас интересует?';
end;

fpc -Fu. -O2 -XX -CX AdvancedChatAI.pas

procedure QuickTraining;
var
  TrainingData: TTrainingDataset;
  startTime: TDateTime;
begin
  if not FileExists('training_data.txt') then
  begin
    WriteLn('Файл training_data.txt не найден, пропускаем обучение');
    Exit;
  end;

  WriteLn('=== БЫСТРОЕ ОБУЧЕНИЕ ===');
  startTime := Now;
  
  // Загружаем данные
  LoadTrainingData(TrainingData, 'training_data.txt');
  FilterEmptyExamples(TrainingData);
  
  if Length(TrainingData) = 0 then
  begin
    WriteLn('Нет данных для обучения');
    Exit;
  end;

  WriteLn('Обучение на ', Length(TrainingData), ' примерах...');
  
  try
    // Быстрое обучение с индексацией
    TrainTransformerWithIndexing(TransformerModel, TrainingData, 3, 0.0001);
    
    WriteLn('Обучение завершено за ', MilliSecondsBetween(Now, startTime), ' мс');
  except
    on E: Exception do
      WriteLn('Ошибка обучения: ', E.Message, ' - продолжаем без обучения');
  end;
end;

// После инициализации модели
WriteLn('Модель инициализирована: InputSize=', TransformerModel.Config.InputSize);

// ✅ БЫСТРОЕ ОБУЧЕНИЕ ПРИ СТАРТЕ
QuickTraining;

if not ValidateModelStructure(TransformerModel) then
begin
  WriteLn('КРИТИЧЕСКАЯ ОШИБКА: Модель не прошла валидацию!');
end;

procedure SimpleHyperparameterTuning;
var
  TrainingData: TTrainingDataset;
  bestLR: Double;
  bestLoss, currentLoss: Double;
  learningRates: array of Double;
  i: Integer;
begin
  if not FileExists('training_data.txt') then Exit;

  WriteLn('=== ПРОСТАЯ ОПТИМИЗАЦИЯ LEARNING RATE ===');
  
  LoadTrainingData(TrainingData, 'training_data.txt');
  FilterEmptyExamples(TrainingData);
  
  if Length(TrainingData) < 10 then
  begin
    WriteLn('Слишком мало данных для оптимизации: ', Length(TrainingData));
    Exit;
  end;

  // Тестируем разные learning rates
  learningRates := [0.001, 0.0005, 0.0001, 0.00005, 0.00001];
  bestLR := 0.0001;
  bestLoss := MaxDouble;

  for i := 0 to High(learningRates) do
  begin
    try
      WriteLn('Тестируем LR=', learningRates[i]:0:6);
      
      // Создаем временную модель для теста
      var tempModel: TTransformer;
      InitTransformer(tempModel, TransformerModel.Config);
      
      // Быстрое обучение на части данных
      var tempData: TTrainingDataset;
      SetLength(tempData, Min(10, Length(TrainingData)));
      Move(TrainingData[0], tempData[0], Length(tempData) * SizeOf(TTrainingExample));
      
      TrainTransformerWithIndexing(tempModel, tempData, 2, learningRates[i]);
      
      // Оцениваем потери
      currentLoss := EvaluateModel(tempModel, tempData);
      WriteLn('  Loss: ', currentLoss:0:4);
      
      if currentLoss < bestLoss then
      begin
        bestLoss := currentLoss;
        bestLR := learningRates[i];
      end;
      
      FreeTransformer(tempModel);
      
    except
      on E: Exception do
        WriteLn('  Ошибка: ', E.Message);
    end;
  end;

  WriteLn('Лучший learning rate: ', bestLR:0:6, ' (loss: ', bestLoss:0:4, ')');
  
  // Применяем лучший LR к основной модели
  if bestLoss < MaxDouble then
  begin
    WriteLn('Применяем лучший LR к основной модели...');
    // Здесь можно переобучить модель с лучшим LR
  end;
end;

// После успешного ответа
if ShouldSaveForTraining(userMessage, response) then
begin
  LearnFromConversation(userMessage, response);
  
  // Периодическое дообучение каждые 10 диалогов
  if (ConversationHistory.Count div 2) mod 10 = 0 then // div 2 потому что пары user+ai
  begin
    WriteLn('=== ИНКРЕМЕНТАЛЬНОЕ ОБУЧЕНИЕ ===');
    IncrementalTraining;
  end;
end;

procedure IncrementalTraining;
var
  TrainingData: TTrainingDataset;
begin
  if not FileExists('auto_learning_data.txt') then Exit;

  try
    LoadTrainingData(TrainingData, 'auto_learning_data.txt');
    FilterEmptyExamples(TrainingData);
    
    if Length(TrainingData) > 5 then // Только если есть новые данные
    begin
      WriteLn('Дообучение на ', Length(TrainingData), ' новых примерах...');
      TrainTransformerWithIndexing(TransformerModel, TrainingData, 1, 0.00001);
      WriteLn('Дообучение завершено');
    end;
  except
    on E: Exception do
      WriteLn('Ошибка инкрементального обучения: ', E.Message);
  end;
end;

procedure FullHyperparameterOptimization;
begin
  if not FileExists('training_data.txt') then
  begin
    WriteLn('Файл training_data.txt не найден');
    WriteLn('Создайте файл с данными обучения в формате:');
    WriteLn('В: вопрос');
    WriteLn('О: ответ');
    WriteLn('К: контекст');
    WriteLn('---');
    Exit;
  end;

  WriteLn('=== ПОЛНАЯ ОПТИМИЗАЦИЯ ГИПЕРПАРАМЕТРОВ ===');
  WriteLn('Это может занять несколько минут...');
  
  try
    OptimizeHyperparameters;
    WriteLn('Оптимизация завершена!');
  except
    on E: Exception do
      WriteLn('Ошибка оптимизации: ', E.Message);
  end;
end;

procedure ShowMenu;
begin
  WriteLn('');
  WriteLn('=== РЕЖИМЫ РАБОТЫ ===');
  WriteLn('1 - Обычный чат');
  WriteLn('2 - Быстрое обучение');
  WriteLn('3 - Оптимизация гиперпараметров');
  WriteLn('4 - Инкрементальное обучение');
  WriteLn('5 - Выход');
  Write('');
end;

function SelectMode: Boolean;
var
  choice: string;
begin
  ShowMenu;
  Write('Выберите режим: ');
  ReadLn(choice);
  
  case choice of
    '1': Result := True; // Обычный чат
    '2': 
      begin
        QuickTraining;
        Result := True;
      end;
    '3':
      begin
        FullHyperparameterOptimization;
        Result := True;
      end;
    '4':
      begin
        IncrementalTraining;
        Result := True;
      end;
    '5': Result := False; // Выход
    else
      begin
        WriteLn('Неверный выбор');
        Result := True;
      end;
  end;
end;

begin
  FpSignal(SIGINT, @HandleSigInt);
  ShowWelcome;
  Initialize;
  
  try
    while not ShouldExit do
    begin
      if SelectMode then
      begin
        WriteLn('Готов к работе! Начинайте общение.');
        WriteLn('');
        
        // Основной цикл чата
        while not ShouldExit do
        begin
          try
            if WaitForUserInput then
            begin
              ProcessUserInput;
              Cleanup;
              
              // Проверяем не хочет ли пользователь выйти из режима чата
              if LastUserMessage.Contains('/меню') or 
                 LastUserMessage.Contains('/exit') or
                 LastUserMessage.Contains('/menu') then
                Break;
            end;
          except
            on E: Exception do
              Writeln('Ошибка: ', E.ClassName, ': ', E.Message);
          end;
        end;
      end
      else
        ShouldExit := True;
    end;
    
  finally
    Cleanup;
    // ... освобождение ресурсов
  end;
end.

unit DecoderUnit;
{$MODE OBJFPC}{$H+}{$RANGECHECKS ON}{$CODEPAGE UTF8}

interface

uses
  SysUtils, Classes, MatrixOps, TextEmbeddings, Word2Vec, ucs4unit, LazUTF8;

type
  TResponseGenerator = class
  private
    FWordEmbeddings: TWordEmbeddings;
    FResponseTemplates: array of record
      Category: string;
      Templates: array of string;
    end;
    
    procedure LoadResponseTemplates;
    function FindBestTemplate(const outputFeatures: TDoubleArray): string;
    function GenerateFromVocabulary(const outputMatrix: TDoubleMatrix): string;
    function CreateContextualResponse(const features: TDoubleArray; const context: string): string;
  public
    constructor Create(AWordEmbeddings: TWordEmbeddings);
    function GenerateResponse(const outputMatrix: TDoubleMatrix; const context: string = ''): string;
    function MatrixToFeatures(const outputMatrix: TDoubleMatrix): TDoubleArray;
  end;

// Вспомогательные функции
function FindClosestWords(const embedding: TDoubleArray; WordEmbeddings: TWordEmbeddings; topK: Integer = 5): TStringArray;
function SampleFromDistribution(const probabilities: TDoubleArray): Integer;
function CreateResponseFromKeywords(const keywords: TStringArray): string;

implementation

constructor TResponseGenerator.Create(AWordEmbeddings: TWordEmbeddings);
begin
  FWordEmbeddings := AWordEmbeddings;
  LoadResponseTemplates;
end;

procedure TResponseGenerator.LoadResponseTemplates;
begin
  SetLength(FResponseTemplates, 8);

  // 1. Приветственные ответы
  FResponseTemplates[0].Category := 'greeting';
  SetLength(FResponseTemplates[0].Templates, 4);
  FResponseTemplates[0].Templates[0] := 'Здравствуйте! Рад вас видеть.';
  FResponseTemplates[0].Templates[1] := 'Привет! Как ваши дела?';
  FResponseTemplates[0].Templates[2] := 'Добрый день! Чем могу помочь?';
  FResponseTemplates[0].Templates[3] := 'Приветствую! Что вас интересует?';

  // 2. Вопросные ответы
  FResponseTemplates[1].Category := 'question';
  SetLength(FResponseTemplates[1].Templates, 4);
  FResponseTemplates[1].Templates[0] := 'Интересный вопрос! Давайте обсудим это.';
  FResponseTemplates[1].Templates[1] := 'Хороший вопрос. Что вы сами об этом думаете?';
  FResponseTemplates[1].Templates[2] := 'Понял ваш вопрос. Могу рассказать подробнее.';
  FResponseTemplates[1].Templates[3] := 'Это действительно важная тема.';

  // 3. Информационные ответы
  FResponseTemplates[2].Category := 'informative';
  SetLength(FResponseTemplates[2].Templates, 4);
  FResponseTemplates[2].Templates[0] := 'По моей информации, это связано с ';
  FResponseTemplates[2].Templates[1] := 'Я считаю, что важно учитывать ';
  FResponseTemplates[2].Templates[2] := 'Интересно, что вы упомянули об этом. ';
  FResponseTemplates[2].Templates[3] := 'В контексте нашего разговора, ';

  // 4. Поддерживающие ответы
  FResponseTemplates[3].Category := 'supportive';
  SetLength(FResponseTemplates[3].Templates, 4);
  FResponseTemplates[3].Templates[0] := 'Понимаю вашу точку зрения.';
  FResponseTemplates[3].Templates[1] := 'Это действительно интересная мысль!';
  FResponseTemplates[3].Templates[2] := 'Спасибо, что поделились этим.';
  FResponseTemplates[3].Templates[3] := 'Я вас понимаю.';

  // 5. Уточняющие ответы
  FResponseTemplates[4].Category := 'clarifying';
  SetLength(FResponseTemplates[4].Templates, 4);
  FResponseTemplates[4].Templates[0] := 'Не могли бы вы уточнить?';
  FResponseTemplates[4].Templates[1] := 'Что именно вас интересует?';
  FResponseTemplates[4].Templates[2] := 'Можете рассказать подробнее?';
  FResponseTemplates[4].Templates[3] := 'Я не совсем понял. Объясните, пожалуйста.';

  // 6. Продолжающие ответы
  FResponseTemplates[5].Category := 'continuing';
  SetLength(FResponseTemplates[5].Templates, 4);
  FResponseTemplates[5].Templates[0] := 'Продолжайте, пожалуйста.';
  FResponseTemplates[5].Templates[1] := 'Интересно! Что еще?';
  FResponseTemplates[5].Templates[2] := 'Расскажите больше об этом.';
  FResponseTemplates[5].Templates[3] := 'И что было дальше?';

  // 7. Заключительные ответы
  FResponseTemplates[6].Category := 'closing';
  SetLength(FResponseTemplates[6].Templates, 4);
  FResponseTemplates[6].Templates[0] := 'Было приятно пообщаться!';
  FResponseTemplates[6].Templates[1] := 'Надеюсь, я был полезен.';
  FResponseTemplates[6].Templates[2] := 'Обращайтесь, если будут вопросы!';
  FResponseTemplates[6].Templates[3] := 'До новых встреч!';

  // 8. Нейтральные ответы
  FResponseTemplates[7].Category := 'neutral';
  SetLength(FResponseTemplates[7].Templates, 4);
  FResponseTemplates[7].Templates[0] := 'Понятно.';
  FResponseTemplates[7].Templates[1] := 'Интересно.';
  FResponseTemplates[7].Templates[2] := 'Я вас слушаю.';
  FResponseTemplates[7].Templates[3] := 'Продолжайте.';
end;

function TResponseGenerator.MatrixToFeatures(const outputMatrix: TDoubleMatrix): TDoubleArray;
var
  i, j: Integer;
  featureSums: TDoubleArray;
begin
  if (Length(outputMatrix) = 0) or (Length(outputMatrix[0]) = 0) then
  begin
    SetLength(Result, 8); // Возвращаем нейтральные фичи
    FillChar(Result[0], Length(Result) * SizeOf(Double), 0);
    Exit;
  end;

  // Создаем 8-мерный вектор признаков из выходной матрицы
  SetLength(featureSums, 8);
  SetLength(Result, 8);
  
  // 1. Уверенность (среднее значение)
  for i := 0 to High(outputMatrix) do
    for j := 0 to High(outputMatrix[i]) do
      featureSums[0] := featureSums[0] + outputMatrix[i][j];
  Result[0] := featureSums[0] / (Length(outputMatrix) * Length(outputMatrix[0]));

  // 2. Вариативность (дисперсия)
  for i := 0 to High(outputMatrix) do
    for j := 0 to High(outputMatrix[i]) do
      featureSums[1] := featureSums[1] + Sqr(outputMatrix[i][j] - Result[0]);
  Result[1] := Sqrt(featureSums[1] / (Length(outputMatrix) * Length(outputMatrix[0])));

  // 3. Максимальная активация
  Result[2] := outputMatrix[0][0];
  for i := 0 to High(outputMatrix) do
    for j := 0 to High(outputMatrix[i]) do
      if outputMatrix[i][j] > Result[2] then
        Result[2] := outputMatrix[i][j];

  // 4. Минимальная активация
  Result[3] := outputMatrix[0][0];
  for i := 0 to High(outputMatrix) do
    for j := 0 to High(outputMatrix[i]) do
      if outputMatrix[i][j] < Result[3] then
        Result[3] := outputMatrix[i][j];

  // 5-8. Активации по квадрантам (упрощенная пространственная информация)
  Result[4] := 0; Result[5] := 0; Result[6] := 0; Result[7] := 0;
  
  for i := 0 to High(outputMatrix) do
  begin
    for j := 0 to High(outputMatrix[i]) do
    begin
      if (i < Length(outputMatrix) div 2) and (j < Length(outputMatrix[i]) div 2) then
        Result[4] := Result[4] + outputMatrix[i][j]
      else if (i < Length(outputMatrix) div 2) and (j >= Length(outputMatrix[i]) div 2) then
        Result[5] := Result[5] + outputMatrix[i][j]
      else if (i >= Length(outputMatrix) div 2) and (j < Length(outputMatrix[i]) div 2) then
        Result[6] := Result[6] + outputMatrix[i][j]
      else
        Result[7] := Result[7] + outputMatrix[i][j];
    end;
  end;
  
  // Нормализуем квадранты
  for i := 4 to 7 do
    Result[i] := Result[i] / ((Length(outputMatrix) * Length(outputMatrix[0])) / 4);
end;

function TResponseGenerator.FindBestTemplate(const outputFeatures: TDoubleArray): string;
var
  i, bestCategory: Integer;
  categoryScores: TDoubleArray;
  maxScore: Double;
begin
  if Length(outputFeatures) < 8 then
  begin
    // Возвращаем нейтральный ответ по умолчанию
    Result := 'Интересно! Расскажите подробнее.';
    Exit;
  end;

  SetLength(categoryScores, Length(FResponseTemplates));
  
  // Вычисляем скоры для каждой категории на основе фичей
  for i := 0 to High(FResponseTemplates) do
  begin
    case i of
      0: // greeting - высокая уверенность + низкая вариативность
        categoryScores[i] := outputFeatures[0] * (1 - outputFeatures[1]);
      1: // question - средняя уверенность + средняя вариативность
        categoryScores[i] := outputFeatures[0] * outputFeatures[1];
      2: // informative - высокая уверенность + активация в первом квадранте
        categoryScores[i] := outputFeatures[0] * outputFeatures[4];
      3: // supportive - средняя уверенность + равномерное распределение
        categoryScores[i] := outputFeatures[0] * (1 - Abs(outputFeatures[4] - outputFeatures[7]));
      4: // clarifying - низкая уверенность + высокая вариативность
        categoryScores[i] := (1 - outputFeatures[0]) * outputFeatures[1];
      5: // continuing - средняя уверенность + активация в последних квадрантах
        categoryScores[i] := outputFeatures[0] * (outputFeatures[6] + outputFeatures[7]);
      6: // closing - низкая уверенность + низкая вариативность
        categoryScores[i] := (1 - outputFeatures[0]) * (1 - outputFeatures[1]);
      7: // neutral - нейтральные значения
        categoryScores[i] := 0.5 * (1 - Abs(outputFeatures[0] - 0.5));
    end;
  end;

  // Находим лучшую категорию
  maxScore := categoryScores[0];
  bestCategory := 0;
  for i := 1 to High(categoryScores) do
  begin
    if categoryScores[i] > maxScore then
    begin
      maxScore := categoryScores[i];
      bestCategory := i;
    end;
  end;

  // Выбираем случайный шаблон из лучшей категории
  if (Length(FResponseTemplates[bestCategory].Templates) > 0) and (maxScore > 0.1) then
  begin
    Result := FResponseTemplates[bestCategory].Templates[
      Random(Length(FResponseTemplates[bestCategory].Templates))
    ];
  end
  else
  begin
    // Fallback на нейтральный ответ
    Result := 'Понятно. Чем еще могу помочь?';
  end;
end;

function TResponseGenerator.GenerateFromVocabulary(const outputMatrix: TDoubleMatrix): string;
var
  i, j: Integer;
  avgEmbedding: TDoubleArray;
  keywords: TStringArray;
begin
  if (FWordEmbeddings = nil) or (Length(outputMatrix) = 0) then
  begin
    Result := '';
    Exit;
  end;

  try
    // Усредняем выходную матрицу в один вектор
    SetLength(avgEmbedding, Length(outputMatrix[0]));
    FillChar(avgEmbedding[0], Length(avgEmbedding) * SizeOf(Double), 0);
    
    for i := 0 to High(outputMatrix) do
      for j := 0 to High(outputMatrix[i]) do
        avgEmbedding[j] := avgEmbedding[j] + outputMatrix[i][j];
        
    for j := 0 to High(avgEmbedding) do
      avgEmbedding[j] := avgEmbedding[j] / Length(outputMatrix);

    // Находим ближайшие слова
    keywords := FindClosestWords(avgEmbedding, FWordEmbeddings, 3);
    
    // Создаем ответ на основе ключевых слов
    if Length(keywords) > 0 then
      Result := CreateResponseFromKeywords(keywords)
    else
      Result := '';

  except
    Result := '';
  end;
end;

function TResponseGenerator.CreateContextualResponse(const features: TDoubleArray; const context: string): string;
var
  baseResponse, contextualPart: string;
begin
  baseResponse := FindBestTemplate(features);
  
  // Добавляем контекстуальную часть если есть контекст
  if context <> '' then
  begin
    if context.Contains('?') then
      contextualPart := 'Относительно вашего вопроса, '
    else if context.Contains('!') then
      contextualPart := 'Как интересно! '
    else if context.Contains('спасибо') then
      contextualPart := 'Пожалуйста! '
    else
      contextualPart := 'Кстати, ';
      
    Result := contextualPart + LowerCase(Copy(baseResponse, 1, 1)) + Copy(baseResponse, 2, Length(baseResponse));
  end
  else
    Result := baseResponse;
end;

function TResponseGenerator.GenerateResponse(const outputMatrix: TDoubleMatrix; const context: string = ''): string;
var
  features: TDoubleArray;
  vocabResponse, templateResponse: string;
begin
  // 1. Извлекаем признаки из выходной матрицы
  features := MatrixToFeatures(outputMatrix);
  
  // 2. Генерируем ответ через шаблоны
  templateResponse := CreateContextualResponse(features, context);
  
  // 3. Пытаемся сгенерировать ответ через словарь (опционально)
  vocabResponse := GenerateFromVocabulary(outputMatrix);
  
  // 4. Комбинируем результаты
  if (vocabResponse <> '') and (Random(100) < 30) then // 30% chance использовать словарный ответ
  begin
    Result := vocabResponse;
  end
  else
  begin
    Result := templateResponse;
    
    // Добавляем вариативность через суффиксы
    case Random(4) of
      0: Result := Result + ' Что вы думаете?';
      1: Result := Result + ' Хотите обсудить это?';
      2: Result := Result + ' Есть ли вопросы?';
      3: ; // Без изменений
    end;
  end;
  
  // Ограничиваем длину ответа
  if UTF8Length(Result) > 200 then
    Result := UTF8Copy(Result, 1, 200) + '...';
end;

// Вспомогательные функции

function FindClosestWords(const embedding: TDoubleArray; WordEmbeddings: TWordEmbeddings; topK: Integer = 5): TStringArray;
var
  i, j, bestIndex: Integer;
  bestSimilarity, similarity: Double;
  similarities: TDoubleArray;
  usedIndices: array of Boolean;
begin
  SetLength(Result, 0);
  if (WordEmbeddings = nil) or (Length(embedding) = 0) then Exit;
  
  SetLength(similarities, WordEmbeddings.FVocab.Count);
  SetLength(usedIndices, WordEmbeddings.FVocab.Count);
  
  try
    // Вычисляем схожести со всеми словами
    for i := 0 to WordEmbeddings.FVocab.Count - 1 do
    begin
      similarities[i] := CosineSimilarity(embedding, WordEmbeddings.GetEmbeddingByIndex(i));
      usedIndices[i] := False;
    end;
    
    // Находим topK самых близких слов
    for i := 1 to Min(topK, WordEmbeddings.FVocab.Count) do
    begin
      bestSimilarity := -2;
      bestIndex := -1;
      
      for j := 0 to WordEmbeddings.FVocab.Count - 1 do
      begin
        if not usedIndices[j] and (similarities[j] > bestSimilarity) then
        begin
          bestSimilarity := similarities[j];
          bestIndex := j;
        end;
      end;
      
      if bestIndex >= 0 then
      begin
        SetLength(Result, Length(Result) + 1);
        Result[High(Result)] := WordEmbeddings.FVocab[bestIndex];
        usedIndices[bestIndex] := True;
      end;
    end;
    
  except
    // В случае ошибки возвращаем пустой массив
    SetLength(Result, 0);
  end;
end;

function SampleFromDistribution(const probabilities: TDoubleArray): Integer;
var
  i: Integer;
  sum, randVal, cumulative: Double;
begin
  sum := 0;
  for i := 0 to High(probabilities) do
    sum := sum + probabilities[i];
    
  if sum = 0 then
  begin
    Result := Random(Length(probabilities));
    Exit;
  end;
  
  randVal := Random * sum;
  cumulative := 0;
  
  for i := 0 to High(probabilities) do
  begin
    cumulative := cumulative + probabilities[i];
    if randVal <= cumulative then
    begin
      Result := i;
      Exit;
    end;
  end;
  
  Result := High(probabilities);
end;

function CreateResponseFromKeywords(const keywords: TStringArray): string;
const
  templates: array[0..7] of string = (
    'Вы упомянули %s. Это интересная тема!',
    'По поводу %s - что именно вас интересует?',
    '%s - хорошее направление для обсуждения.',
    'Мне нравится, что вы затронули тему %s.',
    'Относительно %s - есть что добавить?',
    '%s действительно важно. Хотите поговорить об этом?',
    'Заметил ваше внимание к %s. Продолжайте!',
    '%s - отличная тема для беседы.'
  );
var
  keywordStr: string;
  i: Integer;
begin
  if Length(keywords) = 0 then
  begin
    Result := '';
    Exit;
  end;
  
  // Объединяем ключевые слова
  keywordStr := keywords[0];
  for i := 1 to High(keywords) do
  begin
    if i = High(keywords) then
      keywordStr := keywordStr + ' и ' + keywords[i]
    else
      keywordStr := keywordStr + ', ' + keywords[i];
  end;
  
  // Выбираем случайный шаблон
  Result := Format(templates[Random(Length(templates))], [keywordStr]);
end;

end.

uses
  ..., DecoderUnit;

var
  ..., ResponseGenerator: TResponseGenerator;

// После загрузки Word2Vec
if Assigned(WordEmbeddings) then
begin
  ResponseGenerator := TResponseGenerator.Create(WordEmbeddings);
  WriteLn('Декодер ответов инициализирован');
end
else
begin
  WriteLn('Внимание: Word2Vec не загружен, декодер будет ограничен');
  ResponseGenerator := TResponseGenerator.Create(nil);
end;

// Вместо вызова GenerateResponseFromOutput
if response = '' then 
begin
  if Assigned(ResponseGenerator) then
    response := ResponseGenerator.GenerateResponse(outputMatrix, GetConversationContext)
  else
    response := GenerateResponseFromOutput(outputMatrix); // fallback
end;

if Assigned(ResponseGenerator) then
  ResponseGenerator.Free;

function TResponseGenerator.MatrixToFeatures(const outputMatrix: TDoubleMatrix): TDoubleArray;
var
  i, j: Integer;
  featureSums: TDoubleArray;
  nonZeroCount: Integer;
begin
  if (Length(outputMatrix) = 0) or (Length(outputMatrix[0]) = 0) then
  begin
    SetLength(Result, 8);
    // ✅ ИСПРАВЛЕНИЕ: Устанавливаем нейтральные значения вместо нулей
    Result[0] := 0.5; // уверенность
    Result[1] := 0.3; // вариативность
    Result[2] := 0.6; // макс активация
    Result[3] := 0.4; // мин активация
    for i := 4 to 7 do Result[i] := 0.5;
    Exit;
  end;

  SetLength(featureSums, 8);
  SetLength(Result, 8);
  
  // ✅ ИСПРАВЛЕНИЕ 1: Нормализуем значения матрицы перед анализом
  var normalizedMatrix := CopyMatrix(outputMatrix);
  var matrixMax := outputMatrix[0][0];
  var matrixMin := outputMatrix[0][0];
  
  // Находим min/max для нормализации
  for i := 0 to High(outputMatrix) do
    for j := 0 to High(outputMatrix[i]) do
    begin
      if outputMatrix[i][j] > matrixMax then matrixMax := outputMatrix[i][j];
      if outputMatrix[i][j] < matrixMin then matrixMin := outputMatrix[i][j];
    end;
  
  // Нормализуем к [0,1]
  if matrixMax > matrixMin then
  begin
    for i := 0 to High(outputMatrix) do
      for j := 0 to High(outputMatrix[i]) do
        normalizedMatrix[i][j] := (outputMatrix[i][j] - matrixMin) / (matrixMax - matrixMin);
  end;

  // 1. Уверенность (среднее нормализованное значение)
  nonZeroCount := 0;
  for i := 0 to High(normalizedMatrix) do
    for j := 0 to High(normalizedMatrix[i]) do
    begin
      featureSums[0] := featureSums[0] + normalizedMatrix[i][j];
      if normalizedMatrix[i][j] > 0.1 then Inc(nonZeroCount);
    end;
  Result[0] := featureSums[0] / (Length(normalizedMatrix) * Length(normalizedMatrix[0]));
  
  // ✅ ИСПРАВЛЕНИЕ 2: Увеличиваем уверенность если много ненулевых активаций
  if nonZeroCount > (Length(normalizedMatrix) * Length(normalizedMatrix[0]) div 4) then
    Result[0] := Min(1.0, Result[0] * 1.3);

  // 2. Вариативность (нормализованная)
  for i := 0 to High(normalizedMatrix) do
    for j := 0 to High(normalizedMatrix[i]) do
      featureSums[1] := featureSums[1] + Sqr(normalizedMatrix[i][j] - Result[0]);
  Result[1] := Sqrt(featureSums[1] / (Length(normalizedMatrix) * Length(normalizedMatrix[0])));

  // 3-4. Макс/мин активации (нормализованные)
  Result[2] := normalizedMatrix[0][0];
  Result[3] := normalizedMatrix[0][0];
  for i := 0 to High(normalizedMatrix) do
    for j := 0 to High(normalizedMatrix[i]) do
    begin
      if normalizedMatrix[i][j] > Result[2] then Result[2] := normalizedMatrix[i][j];
      if normalizedMatrix[i][j] < Result[3] then Result[3] := normalizedMatrix[i][j];
    end;

  // 5-8. Квадранты (упрощенные)
  Result[4] := 0; Result[5] := 0; Result[6] := 0; Result[7] := 0;
  var quadrantSize := (Length(normalizedMatrix) * Length(normalizedMatrix[0])) div 4;
  if quadrantSize = 0 then quadrantSize := 1;
  
  for i := 0 to High(normalizedMatrix) do
  begin
    for j := 0 to High(normalizedMatrix[i]) do
    begin
      if (i < Length(normalizedMatrix) div 2) and (j < Length(normalizedMatrix[i]) div 2) then
        Result[4] := Result[4] + normalizedMatrix[i][j]
      else if (i < Length(normalizedMatrix) div 2) and (j >= Length(normalizedMatrix[i]) div 2) then
        Result[5] := Result[5] + normalizedMatrix[i][j]
      else if (i >= Length(normalizedMatrix) div 2) and (j < Length(normalizedMatrix[i]) div 2) then
        Result[6] := Result[6] + normalizedMatrix[i][j]
      else
        Result[7] := Result[7] + normalizedMatrix[i][j];
    end;
  end;
  
  // Нормализуем квадранты
  for i := 4 to 7 do
    Result[i] := Result[i] / quadrantSize;
end;

function TResponseGenerator.FindBestTemplate(const outputFeatures: TDoubleArray): string;
var
  i, bestCategory: Integer;
  categoryScores: TDoubleArray;
  maxScore: Double;
begin
  if Length(outputFeatures) < 8 then
  begin
    // ✅ ИСПРАВЛЕНИЕ 3: Более осмысленный fallback
    Result := 'Интересная информация! Что вы об этом думаете?';
    Exit;
  end;

  SetLength(categoryScores, Length(FResponseTemplates));
  
  // ✅ ИСПРАВЛЕНИЕ 4: Улучшенная логика выбора категорий
  for i := 0 to High(FResponseTemplates) do
  begin
    case i of
      0: // greeting - высокая уверенность + низкая вариативность
        categoryScores[i] := outputFeatures[0] * (1 - outputFeatures[1]) * 1.2;
      1: // question - средняя уверенность + равномерное распределение
        categoryScores[i] := outputFeatures[0] * (1 - Abs(outputFeatures[4] - outputFeatures[7])) * 1.1;
      2: // informative - высокая уверенность + активация в первом квадранте
        categoryScores[i] := outputFeatures[0] * outputFeatures[4] * 1.3;
      3: // supportive - средняя уверенность + низкая вариативность
        categoryScores[i] := outputFeatures[0] * (1 - outputFeatures[1]);
      4: // clarifying - НИЗКАЯ уверенность + высокая вариативность
        categoryScores[i] := (1 - outputFeatures[0]) * outputFeatures[1] * 0.7; // ↓ понижаем вес
      5: // continuing - средняя уверенность + активация в последних квадрантах
        categoryScores[i] := outputFeatures[0] * (outputFeatures[6] + outputFeatures[7]) * 1.1;
      6: // closing - низкая уверенность + низкая вариативность
        categoryScores[i] := (1 - outputFeatures[0]) * (1 - outputFeatures[1]);
      7: // neutral - запасной вариант
        categoryScores[i] := 0.6 * (1 - Abs(outputFeatures[0] - 0.5));
    end;
    
    // ✅ ИСПРАВЛЕНИЕ 5: Минимальный порог для избегания случайных выборов
    if categoryScores[i] < 0.1 then
      categoryScores[i] := 0;
  end;

  // Находим лучшую категорию
  maxScore := categoryScores[0];
  bestCategory := 0;
  for i := 1 to High(categoryScores) do
  begin
    if categoryScores[i] > maxScore then
    begin
      maxScore := categoryScores[i];
      bestCategory := i;
    end;
  end;

  // ✅ ИСПРАВЛЕНИЕ 6: Fallback на нейтральные ответы если все скоры низкие
  if maxScore < 0.15 then
    bestCategory := 7; // neutral category

  // Выбираем случайный шаблон из лучшей категории
  if Length(FResponseTemplates[bestCategory].Templates) > 0 then
  begin
    Result := FResponseTemplates[bestCategory].Templates[
      Random(Length(FResponseTemplates[bestCategory].Templates))
    ];
    
    // ✅ ИСПРАВЛЕНИЕ 7: Логируем выбор для отладки
    WriteLn('Debug: Категория=', FResponseTemplates[bestCategory].Category, 
            ' Уверенность=', outputFeatures[0]:0:3,
            ' Скор=', maxScore:0:3);
  end
  else
  begin
    Result := 'Интересно! Расскажите подробнее.';
  end;
end;

function TResponseGenerator.GenerateFromVocabulary(const outputMatrix: TDoubleMatrix): string;
var
  i, j: Integer;
  avgEmbedding: TDoubleArray;
  keywords: TStringArray;
  validKeywords: TStringList;
begin
  if (FWordEmbeddings = nil) or (Length(outputMatrix) = 0) then
  begin
    Result := '';
    Exit;
  end;

  try
    // Усредняем выходную матрицу в один вектор
    SetLength(avgEmbedding, Length(outputMatrix[0]));
    FillChar(avgEmbedding[0], Length(avgEmbedding) * SizeOf(Double), 0);
    
    for i := 0 to High(outputMatrix) do
      for j := 0 to High(outputMatrix[i]) do
        avgEmbedding[j] := avgEmbedding[j] + outputMatrix[i][j];
        
    for j := 0 to High(avgEmbedding) do
      avgEmbedding[j] := avgEmbedding[j] / Length(outputMatrix);

    // ✅ ИСПРАВЛЕНИЕ 8: Фильтруем ключевые слова
    keywords := FindClosestWords(avgEmbedding, FWordEmbeddings, 10); // Берем больше слов
    
    validKeywords := TStringList.Create;
    try
      // Фильтруем только осмысленные слова (длина > 3, не служебные)
      for i := 0 to High(keywords) do
      begin
        if (UTF8Length(keywords[i]) >= 4) and 
           (not keywords[i].Contains('.')) and
           (not keywords[i].Contains(',')) and
           (not keywords[i].Contains('0')) and
           (not keywords[i].Contains('1')) and
           (not keywords[i].Contains('2')) and
           (not keywords[i].Contains('3')) and
           (not keywords[i].Contains('4')) and
           (not keywords[i].Contains('5')) and
           (not keywords[i].Contains('6')) and
           (not keywords[i].Contains('7')) and
           (not keywords[i].Contains('8')) and
           (not keywords[i].Contains('9')) then
        begin
          validKeywords.Add(keywords[i]);
        end;
      end;
      
      // Берем только 2-3 лучших ключевых слова
      SetLength(keywords, Min(3, validKeywords.Count));
      for i := 0 to High(keywords) do
        keywords[i] := validKeywords[i];
        
    finally
      validKeywords.Free;
    end;
    
    // Создаем ответ на основе ключевых слов
    if Length(keywords) > 0 then
    begin
      Result := CreateResponseFromKeywords(keywords);
      WriteLn('Debug: Ключевые слова: ', string.Join(', ', keywords));
    end
    else
      Result := '';

  except
    on E: Exception do
    begin
      WriteLn('Ошибка в GenerateFromVocabulary: ', E.Message);
      Result := '';
    end;
  end;
end;

function TResponseGenerator.GenerateResponse(const outputMatrix: TDoubleMatrix; const context: string = ''): string;
var
  features: TDoubleArray;
  vocabResponse, templateResponse: string;
  useVocabResponse: Boolean;
begin
  // ✅ ИСПРАВЛЕНИЕ 9: Улучшенная логика комбинирования
  
  // 1. Извлекаем признаки из выходной матрицы
  features := MatrixToFeatures(outputMatrix);
  
  // 2. Генерируем ответ через шаблоны
  templateResponse := CreateContextualResponse(features, context);
  
  // 3. Пытаемся сгенерировать ответ через словарь
  vocabResponse := GenerateFromVocabulary(outputMatrix);
  
  // 4. Решаем какой ответ использовать
  useVocabResponse := (vocabResponse <> '') and 
                     (features[0] > 0.4) and // Достаточная уверенность
                     (Random(100) < 40); // 40% chance
  
  if useVocabResponse then
  begin
    Result := vocabResponse;
    WriteLn('Debug: Используем словарный ответ');
  end
  else
  begin
    Result := templateResponse;
    
    // ✅ ИСПРАВЛЕНИЕ 10: Более осмысленные суффиксы
    if features[0] > 0.6 then // Высокая уверенность
    begin
      case Random(3) of
        0: Result := Result + ' Что вы об этом думаете?';
        1: Result := Result + ' Интересно ваше мнение.';
        2: ; // Без изменений
      end;
    end
    else if features[0] < 0.3 then // Низкая уверенность
    begin
      case Random(3) of
        0: Result := Result + ' Можете уточнить?';
        1: Result := Result + ' Правильно ли я понял?';
        2: ; // Без изменений
      end;
    end;
  end;
  
  // Ограничиваем длину ответа
  if UTF8Length(Result) > 200 then
    Result := UTF8Copy(Result, 1, 200) + '...';
end;